//
// Created by pzw on 24-3-1.
//

#include "LinkedList.h"

template<typename E>
bool LinkedList<E>::add(E e) {
    vec.push_back(e);
    return true;
}

template<typename E>
void LinkedList<E>::add(int index, E element) {
    if (index < 0 || index > vec.size()) {
        std::cout << "Invalid index." << std::endl;
        return;
    }

    typename std::list<E>::iterator begin = vec.begin();
    std::advance(begin, index);
    vec.insert(begin, element);
}

template<typename E>
void LinkedList<E>::addFirst(E e) {
    vec.push_front(e);
}

template<typename E>
void LinkedList<E>::addLast(E e) {
    vec.push_back(e);
}

template<typename E>
void LinkedList<E>::clear() {
    vec.clear();
}

template<typename E>
template<typename T>
T LinkedList<E>::clone() {
    LinkedList<T> clonedList;
    for (const auto &element: vec) {
        clonedList.add(element);
    }
    return clonedList;
}

template<typename E>
bool LinkedList<E>::contains(E o) {
    for (const E &item: vec) {
        if (item == o) {
            return true;
        }
    }
    return false;
}

template<typename E>
LinkedIterator<E> LinkedList<E>::descendingIterator() {
    return LinkedIterator<E>(vec);
}

template<typename E>
E LinkedList<E>::element() {
    if (vec.empty()) {
        std::cout << "NoSuchElementException" << std::endl;
        return E();
    }
    return vec.front();
}

template<typename E>
E LinkedList<E>::get(int index) {
    if (index < 0 || index >= vec.size()) {
        throw std::runtime_error("err index");
    }

    typename std::list<E>::const_iterator it = vec.begin(); // 获取迭代器指向第一个元素
    std::advance(it, index); // 移动迭代器到指定位置
    return *it; // 返回该位置的元素
}

template<typename E>
E LinkedList<E>::getFirst() {
    return vec.front();
}

template<typename E>
E LinkedList<E>::getLast() {
    return vec.end();
}

template<typename E>
int LinkedList<E>::indexOf(E o) {
    int index = 0; // 用于跟踪当前索引位置
    for (auto it = vec.begin(); it != vec.end(); ++it, ++index) {
        if (*it == o) {
            return index; // 找到元素，返回当前索引
        }
    }
    return -1; // 未找到元素，返回-1
}

template<typename E>
int LinkedList<E>::lastIndexOf(E o) {
    int index = 0; // 用于跟踪当前索引位置
    int lastIndex = -1; // 存储最后一次找到元素的索引，初始值为-1
    for (auto it = vec.begin(); it != vec.end(); ++it, ++index) {
        if (*it == o) {
            lastIndex = index; // 更新最后一次找到元素的索引
        }
    }
    return lastIndex; // 返回最后一次找到元素的索引，如果未找到则为-1
}

template<typename E>
LinkedListIterator<E> LinkedList<E>::listIterator() {
    return LinkedListIterator<E>(vec);
}

template<typename E>
bool LinkedList<E>::offer(E e) {
    vec.push_back(e);
    return true;
}

template<typename E>
bool LinkedList<E>::offerFirst(E e) {
    vec.push_front(e);
    return true;
}

template<typename E>
bool LinkedList<E>::offerLast(E e) {
    vec.push_back(e);
    return true;
}

template<typename E>
E *LinkedList<E>::peek() {
    if (vec.empty()) {
        return nullptr; // 列表为空时返回nullptr
    }
    return &vec.front(); // 返回指向第一个元素的指针
}

template<typename E>
E *LinkedList<E>::peekFirst() {
    if (vec.empty()) {
        return nullptr; // 列表为空时返回nullptr
    }
    return &vec.front(); // 返回指向第一个元素的指针
}

template<typename E>
E *LinkedList<E>::peekLast() {
    if (vec.empty()) {
        return nullptr; // 列表为空时返回nullptr
    }
    return &vec.end(); // 返回指向第一个元素的指针
}

template<typename E>
E *LinkedList<E>::poll() {
    return nullptr;
}

template<typename E>
E *LinkedList<E>::pollFirst() {
    return nullptr;
}

template<typename E>
E *LinkedList<E>::pollLast() {
    return nullptr;
}

template<typename E>
E *LinkedList<E>::pop() {
    return nullptr;
}

template<typename E>
void LinkedList<E>::push(E e) {

}

template<typename E>
bool LinkedList<E>::remove(E &o) {
    vec.remove(o);
    return true;
}

template<typename E>
bool LinkedList<E>::removeFirstOccurrence(E o) {
    return false;
}

template<typename E>
bool LinkedList<E>::removeLastOccurrence(E o) {
    return false;
}

template<typename E>
E LinkedList<E>::remove(int index) {
    if (index < 0 || index >= vec.size()) {
        throw std::out_of_range("Index out of range");
    }

    E removedElement = vec[index];
    vec.erase(vec.begin() + index);
    return removedElement;
}

template<typename E>
E LinkedList<E>::set(int index, E element) {
    if (index < 0 || index >= vec.size()) {
        throw std::out_of_range("IndexOutOfBoundsException");
    }

    typename std::list<E>::iterator it = vec.begin();
    std::advance(it, index); // 移动迭代器到指定位置
    E oldElement = *it; // 保存被替换的元素
    *it = element; // 进行替换
    return oldElement; // 返回被替换的元素
}

template<typename E>
int LinkedList<E>::size() {
    return vec.size();
}

template<typename E>
std::vector<E> LinkedList<E>::toArray() {
    /* 将链表转换为数组(在C++中使用vector代替数组) */
    std::vector<E> array;
    for (auto &element: vec) {
        array.push_back(element);
    }
    return array;
}

template<typename E>
std::vector<E> LinkedList<E>::toArray2(LinkedList<E> a) {
    return nullptr;
}

int list_api_main() {
    /* 初始化LinkedList */
    LinkedList<int> *linkedList = new LinkedList<int>();
    if (!linkedList->contains(0)) {
        linkedList->add(0);
        linkedList->add(1);
        linkedList->add(2);
        linkedList->add(3);
        linkedList->add(4);
        linkedList->add(5);
        linkedList->add(6);
        linkedList->add(7);
    }

    /* 迭代器 */
    LinkedIterator<int> it = linkedList->descendingIterator();
    while (it.hasNext()) {
        int e = it.next();
        if (e == 3) {
            it.remove();
        }
    }

    /* 遍历LinkedList */
    for (int i = 0; i < linkedList->size(); ++i) {
        int e = linkedList->get(i);
        if (e == 3) {
            if (i + 1 < linkedList->size()) {
                linkedList->set(i + 1, e);
            } else {
                linkedList->set(i, e);
            }
            break;
        }
    }

    delete linkedList;
    return 0;
}